{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 重试与纠错机制",
   "id": "11ebda519c1402f2"
  },
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-07-26T06:23:45.653074Z",
     "start_time": "2025-07-26T06:23:45.625771Z"
    }
   },
   "source": [
    "import operator\n",
    "import random\n",
    "from typing import Union, Annotated, List\n",
    "\n",
    "from langgraph.graph import StateGraph, END\n",
    "from pydantic import BaseModel\n",
    "\n",
    "\n",
    "class AgentState(BaseModel):\n",
    "    task_description: str  #任务描述\n",
    "    current_attempt_output: Union[str, None]  #当前任务的输出\n",
    "    validation_passed: Union[str, None]  #验证是否通过\n",
    "    error_message: Union[str, None]\n",
    "    correction_suggestions: Annotated[List[str], operator.add]  #累计修正建议\n",
    "    action_retries_left: int  #动作剩余重试次数\n",
    "    correction_cycles_left: int  #修正循环次数\n",
    "    final_result: Union[str, None]  #最终结果\n",
    "    log: Annotated[List[str], operator.add]  #累计的日志\n",
    "\n",
    "\n",
    "def initial_state(state: AgentState):\n",
    "    \"\"\"初始化或重置执行时开始的状态\"\"\"\n",
    "    log_entry = \"------初始化状态------\"\n",
    "    print(log_entry)\n",
    "    return {\n",
    "        \"current_attempt_output\": None,\n",
    "        \"validation_passed\": None,\n",
    "        \"error_message\": None,\n",
    "        \"correction_suggestions\": [],  # 清空之前的建议\n",
    "        \"final_result\": None,\n",
    "        \"log\": [log_entry],\n",
    "        # action_retries_left 和 correction_cycles_left 会在图调用时通过输入设置\n",
    "    }\n",
    "\n",
    "\n",
    "def execute_action(state: AgentState):\n",
    "    \"\"\"\n",
    "    模拟执行主要动作的节点。\n",
    "    这个动作可能会失败，或者产生需要修正的结果。\n",
    "    \"\"\"\n",
    "    log_entry = f\"--- 尝试执行动作 (剩余API重试: {state['action_retries_left']}) ---\"\n",
    "    print(log_entry)\n",
    "\n",
    "    if state[\"action_retries_left\"] <= 0:\n",
    "        err_msg = \"已达到最大API重试次数。\"\n",
    "        print(err_msg)\n",
    "        return {\"error_message\": err_msg, \"log\": [log_entry, err_msg]}\n",
    "\n",
    "    # 从修正建议中获取最新的提示（如果有）\n",
    "    task = state.task_description\n",
    "    suggestions = state.correction_suggestions\n",
    "    if suggestions and len(suggestions) > 0:\n",
    "        task += \"(修正提示:\" + suggestions[-1] + \")\"\n",
    "\n",
    "    # 模拟API调用或复杂操作\n",
    "    # 20% 几率API调用失败\n",
    "    if random.random() < 0.2:\n",
    "        err_msg = \"模拟API调用失败。\"\n",
    "        print(err_msg)\n",
    "        return {\n",
    "            \"current_attempt_output\": None,\n",
    "            \"error_message\": err_msg,\n",
    "            \"action_retries_left\": state[\"action_retries_left\"] - 1,\n",
    "            \"log\": [log_entry, err_msg],\n",
    "        }\n",
    "\n",
    "    # 模拟内容生成\n",
    "    # 50% 几率生成的内容不完美，需要修正\n",
    "    if random.random() < 0.5:\n",
    "        output = f\"关于“{task}”的初步内容，但可能有点短。\"\n",
    "        print(f\"生成了初步但不完美的内容: {output}\")\n",
    "    else:\n",
    "        output = f\"关于“{task}”的完美且详细的内容，符合所有要求。\"\n",
    "        print(f\"生成了看似完美的内容: {output}\")\n",
    "\n",
    "    return {\n",
    "        \"current_attempt_output\": output,\n",
    "        \"error_message\": None,  # 清除之前的错误\n",
    "        \"log\": [log_entry, f\"动作产出: {output}\"],\n",
    "    }\n",
    "\n",
    "\n",
    "def validate_output(state: AgentState):\n",
    "    \"\"\"\n",
    "    验证动作的输出。\n",
    "    \"\"\"\n",
    "    log_entry = \"--- 验证输出 ---\"\n",
    "    print(log_entry)\n",
    "    output = state.current_attempt_output\n",
    "\n",
    "    if not output:\n",
    "        err_msg = \"没有输出可供验证 (可能是因为API重试耗尽)。\"\n",
    "        print(err_msg)\n",
    "        return {\"validation_passed\": False, \"error_message\": state.error_message or err_msg,\n",
    "                \"log\": [log_entry, err_msg]}\n",
    "\n",
    "    # 简单验证规则：\n",
    "    # 1. 必须包含 \"完美\" 这个词 (模拟关键词检查)\n",
    "    # 2. 长度必须大于30个字符 (模拟长度检查)\n",
    "    passed_keywords = \"完美\" in output\n",
    "    passed_length = len(output) > 30\n",
    "\n",
    "    if passed_keywords and passed_length:\n",
    "        msg = \"验证通过！\"\n",
    "        print(msg)\n",
    "        return {\"validation_passed\": True, \"final_result\": output, \"log\": [log_entry, msg]}\n",
    "    else:\n",
    "        suggestions = []\n",
    "        if not passed_keywords:\n",
    "            suggestions.append(\"请确保包含关键词“完美”。\")\n",
    "        if not passed_length:\n",
    "            suggestions.append(\"请确保内容足够长（大于30字符）。\")\n",
    "\n",
    "        suggestion_str = \" \".join(suggestions)\n",
    "        msg = f\"验证失败。建议: {suggestion_str}\"\n",
    "        print(msg)\n",
    "        return {\n",
    "            \"validation_passed\": False,\n",
    "            \"correction_suggestions\": [suggestion_str],  # 添加新的修正建议\n",
    "            \"log\": [log_entry, msg],\n",
    "        }\n",
    "\n",
    "\n",
    "def prepare_for_correction(state: AgentState):\n",
    "    \"\"\"如果验证失败，且还有修正次数，则准备下一次尝试。\"\"\"\n",
    "    log_entry = f\"--- 准备修正 (剩余修正次数: {state.correction_cycles_left}) ---\"\n",
    "    print(log_entry)\n",
    "\n",
    "    if state.correction_cycles_left <= 0:\n",
    "        err_msg = \"已达到最大修正次数。\"\n",
    "        print(err_msg)\n",
    "        # 即使修正次数耗尽，也标记为错误，以便路由到结束\n",
    "        return {\"error_message\": err_msg, \"log\": [log_entry, err_msg]}\n",
    "\n",
    "    return {\n",
    "        \"correction_cycles_left\": state.correction_cycles_left - 1,\n",
    "        \"action_retries_left\": 3,  # 每次修正后，重置API调用重试次数\n",
    "        \"current_attempt_output\": None,  # 清除旧输出\n",
    "        \"validation_passed\": None,  # 重置验证状态\n",
    "        \"log\": [log_entry],\n",
    "    }\n",
    "\n",
    "\n",
    "def decide_after_action(state: AgentState):\n",
    "    \"\"\"在执行动作后决定下一步：验证、重试API或结束\"\"\"\n",
    "    print(\"--- 判断动作后路径 ---\")\n",
    "    if state.error_message and \"API调用失败\" in state.error_message:\n",
    "        if state.action_retries_left > 0:\n",
    "            print(\"决策：API失败，但可重试动作。\")\n",
    "            return \"retry_action\"  # 直接重试动作\n",
    "        else:\n",
    "            print(\"决策：API失败且无重试次数，结束。\")\n",
    "            return END  # API重试耗尽，结束\n",
    "    elif state.error_message:  # 其他错误，例如最大重试次数已到\n",
    "        print(f\"决策：发生错误 '{state.error_message}'，结束。\")\n",
    "        return END\n",
    "    else:\n",
    "        print(\"决策：动作成功，进行验证。\")\n",
    "        return \"validate\"\n",
    "\n",
    "\n",
    "def decide_after_validation(state: AgentState):\n",
    "    \"\"\"在验证后决定下一步：成功结束、尝试修正或失败结束\"\"\"\n",
    "    print(\"--- 判断验证后路径 ---\")\n",
    "    if state.validation_passed is True:\n",
    "        print(\"决策：验证通过，成功结束。\")\n",
    "        return END\n",
    "    else: # 验证失败\n",
    "        if state.error_message and \"没有输出可供验证\" in state.error_message:\n",
    "            print(\"决策：验证因无输出而失败，结束。\") # 通常是因为API重试耗尽\n",
    "            return END\n",
    "        if state.correction_cycles_left> 0:\n",
    "            print(\"决策：验证失败，但可修正。\")\n",
    "            return \"needs_correction\"\n",
    "        else:\n",
    "            print(\"决策：验证失败且无修正次数，结束。\")\n",
    "            # 将当前不完美的输出作为最终结果（或者设为None）\n",
    "            state[\"final_result\"] = state[\"current_attempt_output\"] # 可选\n",
    "            return END\n",
    "\n",
    "\n",
    "# --- 4. 构建图 ---\n",
    "workflow = StateGraph(AgentState)\n",
    "\n",
    "workflow.add_node(\"initializer\", initial_state)\n",
    "workflow.add_node(\"action_executor\", execute_action)\n",
    "workflow.add_node(\"validator\", validate_output)\n",
    "workflow.add_node(\"corrector_setup\", prepare_for_correction)\n",
    "\n",
    "workflow.set_entry_point(\"initializer\")\n",
    "\n",
    "workflow.add_edge(\"initializer\", \"action_executor\")\n",
    "\n",
    "# 条件边: 从动作执行后\n",
    "workflow.add_conditional_edges(\n",
    "    \"action_executor\",\n",
    "    decide_after_action,\n",
    "    {\n",
    "        \"validate\": \"validator\",\n",
    "        \"retry_action\": \"action_executor\", # 直接回到action_executor进行API重试\n",
    "        END: END\n",
    "    }\n",
    ")\n",
    "\n",
    "# 条件边: 从验证后\n",
    "workflow.add_conditional_edges(\n",
    "    \"validator\",\n",
    "    decide_after_validation,\n",
    "    {\n",
    "        \"needs_correction\": \"corrector_setup\",\n",
    "        END: END\n",
    "    }\n",
    ")\n",
    "\n",
    "# 从修正准备回到动作执行器\n",
    "workflow.add_edge(\"corrector_setup\", \"action_executor\")\n",
    "\n",
    "\n",
    "# --- 5. 编译并运行图 ---\n",
    "app = workflow.compile()\n"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-07-26T06:23:45.896722Z",
     "start_time": "2025-07-26T06:23:45.666368Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from IPython.display import Image, display\n",
    "\n",
    "display(Image(app.get_graph().draw_mermaid_png()))"
   ],
   "id": "44d6ee4b309bba30",
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 7
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
